🔧 Le Funzioni in C

#include <stdio.h>

// Funzione che modifica la variabile originale tramite puntatore
void modificaEffettiva(int *ptr) {  // ← Parametro è un PUNTATORE a int
    printf("  Dentro la funzione, indirizzo: %p\n", (void*)ptr);
    printf("  Dentro la funzione, prima: *ptr = %d\n", *ptr);
    
    *ptr = 100;  // ← Dereferenzia il puntatore e modifica il valore puntato
    
    printf("  Dentro la funzione, dopo: *ptr = %d\n", *ptr);
}

int main(void) {
    int numero = 42;
    
    printf("Indirizzo di numero: %p\n", (void*)&numero);
    printf("Prima della chiamata: numero = %d\n", numero);
    
    modificaEffettiva(&numero);  // ← Passiamo l'INDIRIZZO di numero
    
    printf("Dopo la chiamata: numero = %d\n", numero);  // numero È CAMBIATO!
    
    return 0;
}

/* OUTPUT (indirizzi variano):
Indirizzo di numero: 0x7ffe8b4c2d1c
Prima della chiamata: numero = 42
  Dentro la funzione, indirizzo: 0x7ffe8b4c2d1c  ← Stesso indirizzo!
  Dentro la funzione, prima: *ptr = 42
  Dentro la funzione, dopo: *ptr = 100
Dopo la chiamata: numero = 100  ← MODIFICATO!

Spiegazione dettagliata:
1. &numero è l'operatore 'address-of': restituisce l'indirizzo di memoria di numero
2. Passiamo questo indirizzo alla funzione: modificaEffettiva(&numero)
3. Il parametro 'ptr' riceve una COPIA dell'indirizzo (pass by value dell'indirizzo)
4. Attraverso l'operatore * (dereferenziazione), accediamo al valore all'indirizzo puntato
5. *ptr = 100 modifica il contenuto della memoria puntata, cioè la variabile originale!
*/

#include <stdio.h>

// Le seguenti dichiarazioni sono EQUIVALENTI in C:
void elabora_array_v1(int arr[], int size);      // Sintassi con []
void elabora_array_v2(int *arr, int size);      // Sintassi con puntatore
// Entrambe significano: "arr è un puntatore a int"

// Implementazione
void elabora_array_v1(int arr[], int size) {
    printf("Dimensione del 'parametro arr': %zu byte\n", sizeof(arr));
    // ⚠️ sizeof(arr) restituisce la dimensione di un PUNTATORE (8 byte su 64-bit),
    //    NON la dimensione dell'array originale!
    
    printf("Modifico gli elementi...\n");
    for (int i = 0; i < size; i++) {
        arr[i] *= 2;  // Modifica l'array ORIGINALE
    }
}

int main(void) {
    int numeri[] = {1, 2, 3, 4, 5};
    int size = sizeof(numeri) / sizeof(numeri[0]);
    
    printf("Dimensione dell'array originale: %d elementi (%zu byte)\n", 
           size, sizeof(numeri));
    
    printf("Array prima: ");
    for (int i = 0; i < size; i++) {
        printf("%d ", numeri[i]);
    }
    printf("\n");
    
    elabora_array_v1(numeri, size);
    
    printf("Array dopo: ");
    for (int i = 0; i < size; i++) {
        printf("%d ", numeri[i]);
    }
    printf("\n");
    
    return 0;
}

/* OUTPUT:
Dimensione dell'array originale: 5 elementi (20 byte)
Array prima: 1 2 3 4 5
Dimensione del 'parametro arr': 8 byte
Modifico gli elementi...
Array dopo: 2 4 6 8 10

Osservazioni chiave:
1. sizeof(numeri) in main() = 20 byte (5 int × 4 byte)
2. sizeof(arr) nella funzione = 8 byte (dimensione di un puntatore su sistema 64-bit)
3. Le modifiche agli elementi si riflettono sull'array originale
4. È ESSENZIALE passare la dimensione come parametro separato
*/

#include <stdio.h>

// Variabile GLOBALE - File scope
// Visibile in tutto il file, dopo la sua dichiarazione
int contatore_globale = 0;

void funzione1(void) {
    // 'x' ha block scope - visibile solo in questa funzione
    int x = 10;
    
    contatore_globale++;  // Accesso alla globale: OK
    printf("funzione1 - x: %d, globale: %d\n", x, contatore_globale);
    
    {
        // Blocco innestato - nuovo scope
        int y = 20;  // 'y' visibile solo in questo blocco
        int x = 100; // Questa 'x' NASCONDE la 'x' esterna (shadowing)
        
        printf("  Blocco interno - x: %d, y: %d\n", x, y);
    }
    
    // Qui 'y' NON esiste più (out of scope)
    // printf("%d", y);  ← ERRORE DI COMPILAZIONE!
    
    // La 'x' originale è di nuovo visibile
    printf("funzione1 - x dopo blocco: %d\n", x);  // Stampa 10, non 100
}

void funzione2(void) {
    // Questa funzione NON può accedere alla 'x' di funzione1
    // Ma può accedere alla variabile globale
    contatore_globale++;
    printf("funzione2 - globale: %d\n", contatore_globale);
    
    // printf("%d", x);  ← ERRORE! 'x' non è visibile qui
}

int main(void) {
    printf("=== Dimostrazione Scope ===\n");
    
    funzione1();
    funzione2();
    funzione1();
    
    printf("main - globale finale: %d\n", contatore_globale);
    
    return 0;
}

/* Concetti chiave:
1. Variabili locali (block scope) sono ISOLATE tra funzioni diverse
2. Variabili globali sono CONDIVISE tra tutte le funzioni
3. Blocchi innestati possono "nascondere" variabili esterne (shadowing)
4. Quando un blocco termina, tutte le sue variabili locali diventano inaccessibili
*/

#include <stdio.h>

void conta_chiamate_automatica(void) {
    int contatore = 0;  // Variabile AUTOMATICA (locale)
    contatore++;
    printf("Conta automatica: %d\n", contatore);
    // Al return, 'contatore' viene DISTRUTTO
}

void conta_chiamate_statica(void) {
    static int contatore = 0;  // Variabile STATICA
    // 'static' qui significa: "esiste per tutta la durata del programma"
    // L'inizializzazione '= 0' avviene UNA SOLA VOLTA, non ad ogni chiamata
    
    contatore++;
    printf("Conta statica: %d\n", contatore);
    // Al return, 'contatore' NON viene distrutto, mantiene il suo valore
}

int main(void) {
    printf("=== Chiamate alla funzione con variabile automatica ===\n");
    conta_chiamate_automatica();  // Stampa: 1
    conta_chiamate_automatica();  // Stampa: 1  ← Sempre 1!
    conta_chiamate_automatica();  // Stampa: 1
    
    printf("\n=== Chiamate alla funzione con variabile statica ===\n");
    conta_chiamate_statica();     // Stampa: 1
    conta_chiamate_statica();     // Stampa: 2  ← Incrementa!
    conta_chiamate_statica();     // Stampa: 3
    
    return 0;
}

/* Spiegazione:
Variabile AUTOMATICA:
- Viene creata ogni volta che la funzione viene chiamata
- Viene inizializzata a 0 ogni volta
- Viene distrutta quando la funzione termina
- Non conserva il valore tra chiamate successive

Variabile STATICA:
- Viene creata UNA SOLA VOLTA all'avvio del programma
- L'inizializzazione '= 0' avviene solo la prima volta
- NON viene distrutta quando la funzione termina
- Conserva il valore tra chiamate successive
- Ma ha ancora block scope: non accessibile fuori dalla funzione
*/

#include <stdio.h>

/**
 * Calcola il fattoriale di n ricorsivamente
 * Definizione matematica:
 *   n! = n × (n-1)!  per n > 0
 *   0! = 1           (caso base)
 */
unsigned long long fattoriale(int n) {
    // CASO BASE: fondamentale per fermare la ricorsione
    if (n == 0 || n == 1) {
        return 1;
    }
    
    // CASO RICORSIVO: riduce il problema a un'istanza più piccola
    return n * fattoriale(n - 1);
}

// Versione con tracciamento per capire il flusso di esecuzione
unsigned long long fattoriale_tracciato(int n, int livello) {
    // Stampa indentazione proporzionale al livello di ricorsione
    for (int i = 0; i < livello; i++) printf("  ");
    printf("→ fattoriale(%d) chiamato\n", n);
    
    if (n == 0 || n == 1) {
        for (int i = 0; i < livello; i++) printf("  ");
        printf("← fattoriale(%d) restituisce 1 (caso base)\n", n);
        return 1;
    }
    
    unsigned long long risultato = n * fattoriale_tracciato(n - 1, livello + 1);
    
    for (int i = 0; i < livello; i++) printf("  ");
    printf("← fattoriale(%d) restituisce %llu\n", n, risultato);
    
    return risultato;
}

int main(void) {
    int n = 5;
    
    printf("Calcolo di %d! = %llu\n\n", n, fattoriale(n));
    
    printf("\n=== Tracciamento delle chiamate ricorsive ===\n");
    fattoriale_tracciato(5, 0);
    
    return 0;
}

/* OUTPUT del tracciamento:
→ fattoriale(5) chiamato
  → fattoriale(4) chiamato
    → fattoriale(3) chiamato
      → fattoriale(2) chiamato
        → fattoriale(1) chiamato
        ← fattoriale(1) restituisce 1 (caso base)
      ← fattoriale(2) restituisce 2
    ← fattoriale(3) restituisce 6
  ← fattoriale(4) restituisce 24
← fattoriale(5) restituisce 120

Analisi del flusso:
1. fattoriale(5) chiama fattoriale(4)
2. fattoriale(4) chiama fattoriale(3)
3. ... fino a fattoriale(1) che raggiunge il CASO BASE
4. fattoriale(1) restituisce 1
5. Questo valore risale attraverso lo stack:
   - fattoriale(2) calcola 2 × 1 = 2
   - fattoriale(3) calcola 3 × 2 = 6
   - fattoriale(4) calcola 4 × 6 = 24
   - fattoriale(5) calcola 5 × 24 = 120
*/

#include <stdio.h>
#include <time.h>

/**
 * Fibonacci ricorsivo INGENUO (molto inefficiente!)
 * Complessità: O(2^n) - esponenziale!
 * 
 * Definizione: fib(n) = fib(n-1) + fib(n-2)
 *              fib(0) = 0, fib(1) = 1
 */
unsigned long long fib_ricorsivo(int n) {
    if (n <= 1) return n;
    return fib_ricorsivo(n - 1) + fib_ricorsivo(n - 2);
}

/**
 * Fibonacci iterativo (molto più efficiente!)
 * Complessità: O(n) - lineare
 */
unsigned long long fib_iterativo(int n) {
    if (n <= 1) return n;
    
    unsigned long long prev = 0, curr = 1;
    
    for (int i = 2; i <= n; i++) {
        unsigned long long next = prev + curr;
        prev = curr;
        curr = next;
    }
    
    return curr;
}

int main(void) {
    int n = 40;
    
    printf("Calcolo di Fibonacci(%d)\n\n", n);
    
    // Test versione ricorsiva (LENTO per n > 35)
    printf("Versione ricorsiva...\n");
    clock_t start = clock();
    unsigned long long ris_ric = fib_ricorsivo(n);
    clock_t end = clock();
    double tempo_ric = ((double)(end - start)) / CLOCKS_PER_SEC;
    
    printf("Risultato: %llu\n", ris_ric);
    printf("Tempo: %.6f secondi\n\n", tempo_ric);
    
    // Test versione iterativa (VELOCE)
    printf("Versione iterativa...\n");
    start = clock();
    unsigned long long ris_iter = fib_iterativo(n);
    end = clock();
    double tempo_iter = ((double)(end - start)) / CLOCKS_PER_SEC;
    
    printf("Risultato: %llu\n", ris_iter);
    printf("Tempo: %.6f secondi\n\n", tempo_iter);
    
    printf("Speedup: %.0fx più veloce!\n", tempo_ric / tempo_iter);
    
    return 0;
}

/* OUTPUT tipico:
Versione ricorsiva...
Risultato: 102334155
Tempo: 1.523400 secondi

Versione iterativa...
Risultato: 102334155
Tempo: 0.000001 secondi

Speedup: 1523400x più veloce!

Perché la ricorsione è così lenta qui?
- fib_ricorsivo(5) calcola fib(4) e fib(3)
- Ma fib(4) ricalcola fib(3) e fib(2)!
- fib(3) viene calcolato DUE VOLTE
- Questa duplicazione cresce esponenzialmente
- Per fib(40), ci sono MILIARDI di calcoli ridondanti!

La versione iterativa calcola ogni fib(i) UNA SOLA VOLTA.
Lezione: la ricorsione non è sempre la soluzione migliore!
*/